home *** CD-ROM | disk | FTP | other *** search
/ The Java 3D API Specification (2nd Edition) / The Java 3D API Specification (2nd Edition).iso / programs / examples / GeometryByReference / GeometryByReferenceTest.java < prev    next >
Text File  |  2000-04-28  |  15KB  |  543 lines
  1. /*
  2.  *    @(#)GeometryByReferenceTest.java 1.4 00/02/10 13:14:00
  3.  *
  4.  * Copyright (c) 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  *
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  *
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  30.  
  31. import java.applet.Applet;
  32. import java.awt.*;
  33. import java.awt.event.*;
  34. import com.sun.j3d.utils.applet.MainFrame;
  35. import com.sun.j3d.utils.geometry.*;
  36. import com.sun.j3d.utils.universe.*;
  37. import javax.media.j3d.*;
  38. import javax.vecmath.*;
  39. import javax.swing.*;
  40. import javax.swing.event.*;
  41. import javax.swing.border.*;
  42. import com.sun.j3d.utils.behaviors.mouse.*;
  43.  
  44. public class GeometryByReferenceTest extends JApplet implements ActionListener,
  45. GeometryUpdater {
  46.  
  47.     RenderingAttributes ra;
  48.     ColoringAttributes ca;
  49.     Material mat;               
  50.     Appearance app;               
  51.     JComboBox geomType;
  52.     JComboBox vertexType;
  53.     JComboBox colorType;
  54.     JCheckBox transparency;
  55.     JComboBox updates;
  56.     Shape3D shape;               
  57.     TransparencyAttributes transp;
  58.     int updateIndex = 0;
  59.     int colorCount = 0, vertexCount = 0;
  60.     int vertexIndex = 0, colorIndex = 0;
  61.     
  62.     GeometryArray tetraRegular, tetraStrip, tetraIndexed, tetraIndexedStrip;
  63.     GeometryArray[] geoArrays = new GeometryArray[4];           
  64.  
  65.     private static final float sqrt3 = (float) Math.sqrt(3.0);
  66.     private static final float sqrt3_3 = sqrt3 / 3.0f;
  67.     private static final float sqrt24_3 = (float) Math.sqrt(24.0) / 3.0f;
  68.  
  69.     private static final float ycenter = 0.5f * sqrt24_3;
  70.     private static final float zcenter = -sqrt3_3;
  71.  
  72.     private static final Point3f p1 = 
  73.     new Point3f(-1.0f, -ycenter, -zcenter);
  74.     private static final Point3f p2 = 
  75.     new Point3f(1.0f, -ycenter, -zcenter);
  76.     private static final Point3f p3 =
  77.     new Point3f(0.0f, -ycenter, -sqrt3 - zcenter);
  78.     private static final Point3f p4 =
  79.     new Point3f(0.0f, sqrt24_3 - ycenter, 0.0f);
  80.  
  81.  
  82.     private static final float[] floatVerts = {
  83.     p1.x, p1.y, p1.z, // front face
  84.     p2.x, p2.y, p2.z,
  85.     p4.x, p4.y, p4.z,
  86.     
  87.     p1.x, p1.y, p1.z,// left, back face
  88.     p4.x, p4.y, p4.z,
  89.     p3.x, p3.y, p3.z,
  90.     
  91.     p2.x, p2.y, p2.z,// right, back face
  92.     p3.x, p3.y, p3.z,
  93.     p4.x, p4.y, p4.z,
  94.     
  95.     p1.x, p1.y, p1.z,// bottom face
  96.     p3.x, p3.y, p3.z,
  97.     p2.x, p2.y, p2.z,
  98.     };
  99.     
  100.     private static final Color3f c1 = new Color3f(0.6f, 0.0f, 0.0f);
  101.     private static final Color3f c2 = new Color3f(0.0f, 0.6f, 0.0f);
  102.     private static final Color3f c3 = new Color3f(0.0f, 0.6f, 0.6f);
  103.     private static final Color3f c4 = new Color3f(0.6f, 0.6f, 0.0f);
  104.  
  105.  
  106.     private static final float[] floatClrs = {
  107.     c1.x, c1.y, c1.z, // front face
  108.     c2.x, c2.y, c2.z,
  109.     c4.x, c4.y, c4.z,
  110.     
  111.     c1.x, c1.y, c1.z,// left, back face
  112.     c4.x, c4.y, c4.z,
  113.     c3.x, c3.y, c3.z,
  114.     
  115.     c2.x, c2.y, c2.z,// right, back face
  116.     c3.x, c3.y, c3.z,
  117.     c4.x, c4.y, c4.z,
  118.     
  119.     c1.x, c1.y, c1.z,// bottom face
  120.     c3.x, c3.y, c3.z,
  121.     c2.x, c2.y, c2.z,
  122.     }    ;
  123.  
  124.     private static final float[] indexedFloatVerts = {
  125.     p1.x,p1.y,p1.z,
  126.     p2.x,p2.y,p2.z,
  127.     p3.x,p3.y,p3.z,
  128.     p4.x,p4.y,p4.z,
  129.  
  130.     };
  131.     private static final float[] indexedFloatClrs = {
  132.     c1.x,c1.y,c1.z,
  133.     c2.x,c2.y,c2.z,
  134.     c3.x,c3.y,c3.z,
  135.     c4.x,c4.y,c4.z,
  136.     };
  137.    private static final Point3f[] p3fVerts = {
  138.     p1, p2, p4, p1, p4, p3, p2, p3, p4, p1, p3, p2};
  139.  
  140.     private static final Point3f[] indexedP3fVerts = {p1, p2, p3, p4};
  141.     
  142.     private static final Color3f[] c3fClrs = {
  143.     c1, c2, c4, c1, c4, c3, c2, c3, c4, c1, c3, c2};
  144.  
  145.     private static final Color3f[] indexedC3fClrs = {c1, c2, c3, c4};
  146.  
  147.     
  148.     private static final int[] indices = {0,1,3,0,3,2,1,2,3,0,2,1};
  149.     private int[] stripVertexCounts = {3,3,3,3};
  150.  
  151.    BranchGroup createSceneGraph() {
  152.     BranchGroup objRoot = new BranchGroup();
  153.  
  154.     // Set up attributes to render lines
  155.         app = new Appearance();
  156.  
  157.     transp = new TransparencyAttributes();
  158.     transp.setTransparency(0.5f);
  159.     transp.setCapability(TransparencyAttributes.ALLOW_MODE_WRITE);
  160.     transp.setTransparencyMode(TransparencyAttributes.NONE);
  161.     app.setTransparencyAttributes(transp);
  162.     
  163.     tetraRegular = createGeometry(1);
  164.     tetraStrip =createGeometry(2);
  165.     tetraIndexed = createGeometry(3);
  166.     tetraIndexedStrip = createGeometry(4);
  167.  
  168.     geoArrays[0] = tetraRegular;
  169.     geoArrays[1] = tetraStrip;
  170.     geoArrays[2] = tetraIndexed;
  171.     geoArrays[3] = tetraIndexedStrip;
  172.     
  173.     shape = new Shape3D(tetraRegular, app);
  174.     shape.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);
  175.     shape.setCapability(Shape3D.ALLOW_GEOMETRY_READ);
  176.  
  177.     Transform3D t = new Transform3D();
  178.     // move the object upwards
  179.     t.set(new Vector3f(0.0f, 0.3f, 0.0f));
  180.  
  181.     // rotate the shape
  182.     Transform3D temp = new Transform3D();
  183.         temp.rotX(Math.PI/4.0d);
  184.     t.mul(temp);
  185.         temp.rotY(Math.PI/4.0d);
  186.         t.mul(temp);
  187.     
  188.     // Shrink the object 
  189.     t.setScale(0.6);
  190.  
  191.     TransformGroup trans = new TransformGroup(t);
  192.     trans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
  193.     trans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
  194.  
  195.     objRoot.addChild(trans);
  196.     trans.addChild(shape);
  197.  
  198.     BoundingSphere bounds =
  199.         new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);
  200.  
  201.     // Create the drag behavior node
  202.     MouseRotate behavior = new MouseRotate();
  203.     behavior.setTransformGroup(trans);
  204.     trans.addChild(behavior);
  205.     behavior.setSchedulingBounds(bounds);
  206.     
  207.     // Create the zoom behavior node
  208.     MouseZoom behavior2 = new MouseZoom();
  209.     behavior2.setTransformGroup(trans);
  210.     trans.addChild(behavior2);
  211.     behavior2.setSchedulingBounds(bounds);
  212.     
  213.     // Create the zoom behavior node
  214.     MouseTranslate behavior3 = new MouseTranslate();
  215.     behavior3.setTransformGroup(trans);
  216.     trans.addChild(behavior3);
  217.     behavior3.setSchedulingBounds(bounds);
  218.  
  219.  
  220.  
  221.     // Set up the global lights
  222.     Color3f lColor1 = new Color3f(0.7f, 0.7f, 0.7f);
  223.     Vector3f lDir1  = new Vector3f(-1.0f, -1.0f, -1.0f);
  224.     Color3f alColor = new Color3f(0.2f, 0.2f, 0.2f);
  225.  
  226.     AmbientLight aLgt = new AmbientLight(alColor);
  227.     aLgt.setInfluencingBounds(bounds);
  228.     DirectionalLight lgt1 = new DirectionalLight(lColor1, lDir1);
  229.     lgt1.setInfluencingBounds(bounds);
  230.     objRoot.addChild(aLgt);
  231.     objRoot.addChild(lgt1);
  232.     
  233.     // Let Java 3D perform optimizations on this scene graph.
  234.         objRoot.compile();
  235.  
  236.     return objRoot;
  237.     }
  238.  
  239.     JPanel createGeometryByReferencePanel() {
  240.     JPanel panel = new JPanel();
  241.     panel.setBorder(new TitledBorder("Geometry Type"));
  242.  
  243.     String values[] = {"Array", "Strip", "Indexed", "IndexedStrip"};
  244.     geomType = new JComboBox(values);
  245.     geomType.setLightWeightPopupEnabled(false);
  246.     geomType.addActionListener(this);
  247.     geomType.setSelectedIndex(0);
  248.     panel.add(new JLabel("Geometry Type"));     
  249.     panel.add(geomType);
  250.  
  251.  
  252.     String vertex_types[] = { "Float","P3F"};
  253.  
  254.     vertexType = new JComboBox(vertex_types);
  255.     vertexType.setLightWeightPopupEnabled(false);
  256.     vertexType.addActionListener(this);
  257.     vertexType.setSelectedIndex(0);
  258.     panel.add(new JLabel("VertexType"));     
  259.     panel.add(vertexType);
  260.  
  261.  
  262.     String color_types[] = { "Float","C3F"};
  263.  
  264.     colorType = new JComboBox(color_types);
  265.     colorType.setLightWeightPopupEnabled(false);
  266.     colorType.addActionListener(this);
  267.     colorType.setSelectedIndex(0);
  268.     panel.add(new JLabel("ColorType"));     
  269.     panel.add(colorType);
  270.     
  271.  
  272.  
  273.  
  274.     return panel;
  275.     }
  276.  
  277.     JPanel createUpdatePanel() {
  278.  
  279.     JPanel panel = new JPanel();
  280.     panel.setBorder(new TitledBorder("Other Attributes"));
  281.  
  282.     String updateComp[] = { "None","Geometry", "Color"};
  283.     
  284.     transparency = new JCheckBox("EnableTransparency", 
  285.                       false);
  286.     transparency.addActionListener(this);
  287.     panel.add(transparency);
  288.  
  289.  
  290.     updates = new JComboBox(updateComp);
  291.     updates.setLightWeightPopupEnabled(false);
  292.     updates.addActionListener(this);
  293.     updates.setSelectedIndex(0);
  294.     panel.add(new JLabel("UpdateData"));     
  295.     panel.add(updates);
  296.  
  297.     return panel;
  298.     }
  299.  
  300.     
  301.  
  302.     public GeometryByReferenceTest() {
  303.     Container contentPane = getContentPane();
  304.     
  305.         Canvas3D c = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
  306.         contentPane.add("Center", c);
  307.  
  308.         BranchGroup scene = createSceneGraph();
  309.         // SimpleUniverse is a Convenience Utility class
  310.         SimpleUniverse u = new SimpleUniverse(c);
  311.  
  312.         // This will move the ViewPlatform back a bit so the
  313.         // objects in the scene can be viewed.
  314.         u.getViewingPlatform().setNominalViewingTransform();
  315.         u.addBranchGraph(scene);
  316.  
  317.  
  318.     // Create GUI
  319.     JPanel p = new JPanel();
  320.     BoxLayout boxlayout = new BoxLayout(p, 
  321.                         BoxLayout.Y_AXIS);
  322.     p.add(createGeometryByReferencePanel());
  323.     p.add(createUpdatePanel());
  324.     p.setLayout(boxlayout);
  325.  
  326.     contentPane.add("South", p);
  327.     
  328.  
  329.  
  330.     }
  331.     public void actionPerformed(ActionEvent e) {
  332.     Object target = e.getSource();
  333.     GeometryArray geo;
  334.     boolean setColor = false, setVertex = false;
  335.     if (target == geomType) {
  336.         geo = geoArrays[geomType.getSelectedIndex()];
  337.         // Set everything to null, and set it later ..
  338.         geo.setColorRefFloat(null);
  339.         geo.setColorRef3f(null);
  340.         geo.setCoordRefFloat(null);
  341.         geo.setCoordRef3f(null);
  342.         shape.setGeometry(geoArrays[geomType.getSelectedIndex()]);
  343.  
  344.         setColor = true;
  345.         setVertex= true;
  346.  
  347.         
  348.     } 
  349.     else if (target == transparency) {
  350.         if (transparency.isSelected()) {
  351.         transp.setTransparencyMode(TransparencyAttributes.BLENDED);
  352.         }
  353.         else {
  354.         transp.setTransparencyMode(TransparencyAttributes.NONE);
  355.         }
  356.  
  357.  
  358.     }
  359.     else if (target == updates) {
  360.         updateIndex = updates.getSelectedIndex();
  361.         if (updateIndex == 1) {
  362.         System.out.println("Doing coordinate update");
  363.         ((GeometryArray)(shape.getGeometry())).updateData(this);
  364.         }
  365.         else if (updateIndex == 2) {
  366.         System.out.println("Doing color update");
  367.         ((GeometryArray)(shape.getGeometry())).updateData(this);
  368.         }
  369.  
  370.     }
  371.     else if (target == vertexType) {
  372.         geo = ((GeometryArray)shape.getGeometry());
  373.         if (vertexIndex == 0) {
  374.         geo.setCoordRefFloat(null);
  375.         }
  376.         else if (vertexIndex == 1) {
  377.         geo.setCoordRef3f(null);
  378.         }
  379.         vertexIndex = vertexType.getSelectedIndex();
  380.         setVertex = true;
  381.     }
  382.     else if (target == colorType) {
  383.         geo = (GeometryArray) shape.getGeometry();
  384.         if (colorIndex == 0) {
  385.         geo.setColorRefFloat(null);
  386.         }
  387.         else if (colorIndex == 1) {
  388.         geo.setColorRef3f(null);
  389.         }
  390.         colorIndex = colorType.getSelectedIndex();
  391.         setColor = true;
  392.     }
  393.  
  394.     if (setVertex) {
  395.         geo = (GeometryArray) shape.getGeometry();
  396.         if (vertexIndex == 0) {
  397.         if (geo instanceof IndexedGeometryArray)
  398.             geo.setCoordRefFloat(indexedFloatVerts);
  399.         else
  400.             geo.setCoordRefFloat(floatVerts);
  401.         }
  402.         else if (vertexIndex == 1) {
  403.         if (geo instanceof IndexedGeometryArray)
  404.             geo.setCoordRef3f(indexedP3fVerts);
  405.         else
  406.             geo.setCoordRef3f(p3fVerts);
  407.         }
  408.  
  409.     }
  410.     if (setColor) {
  411.         geo = (GeometryArray) shape.getGeometry();
  412.         if (colorIndex == 0) {
  413.         if (geo instanceof IndexedGeometryArray)
  414.             geo.setColorRefFloat(indexedFloatClrs);
  415.         else
  416.             geo.setColorRefFloat(floatClrs);
  417.         }
  418.         else if (colorIndex == 1) {
  419.         if (geo instanceof IndexedGeometryArray)
  420.             geo.setColorRef3f(indexedC3fClrs);
  421.         else
  422.             geo.setColorRef3f(c3fClrs);
  423.         }
  424.     }
  425.  
  426.     }
  427.  
  428.  
  429.                
  430.     public static void main(String[] args) {
  431.     Frame frame = new MainFrame(new GeometryByReferenceTest(), 800, 800);
  432.     }
  433.                
  434.     public GeometryArray createGeometry (int type) {
  435.     GeometryArray tetra = null;
  436.     if (type == 1) {
  437.         tetra =new TriangleArray(12, 
  438.                      TriangleArray.COORDINATES|
  439.                      TriangleArray.COLOR_3|
  440.                      TriangleArray.BY_REFERENCE);
  441.         
  442.         tetra.setCoordRefFloat(floatVerts);
  443.         tetra.setColorRefFloat(floatClrs);
  444.  
  445.     }
  446.     else if (type == 2) {
  447.         tetra = new TriangleStripArray(12,
  448.                        TriangleStripArray.COORDINATES|
  449.                        TriangleStripArray.COLOR_3|
  450.                        TriangleStripArray.BY_REFERENCE,
  451.                        stripVertexCounts);
  452.         tetra.setCoordRefFloat(floatVerts);
  453.         tetra.setColorRefFloat(floatClrs);
  454.         
  455.     }
  456.     else if (type == 3) { // Indexed Geometry
  457.         tetra = new IndexedTriangleArray(4,
  458.                          IndexedTriangleArray.COORDINATES|
  459.                          IndexedTriangleArray.COLOR_3|
  460.                          IndexedTriangleArray.BY_REFERENCE,
  461.                          12);
  462.         tetra.setCoordRefFloat(indexedFloatVerts);
  463.         tetra.setColorRefFloat(indexedFloatClrs);
  464.         ((IndexedTriangleArray)tetra).setCoordinateIndices(0, indices);
  465.         ((IndexedTriangleArray)tetra).setColorIndices(0, indices);
  466.     }
  467.     else if (type == 4) { // Indexed strip geometry
  468.         tetra = new IndexedTriangleStripArray(4,
  469.                           IndexedTriangleStripArray.COORDINATES|
  470.                           IndexedTriangleStripArray.COLOR_3|
  471.                           IndexedTriangleStripArray.BY_REFERENCE,
  472.                           12,
  473.                           stripVertexCounts);
  474.         tetra.setCoordRefFloat(indexedFloatVerts);
  475.         tetra.setColorRefFloat(indexedFloatClrs);
  476.         ((IndexedTriangleStripArray)tetra).setCoordinateIndices(0, indices);
  477.         ((IndexedTriangleStripArray)tetra).setColorIndices(0, indices);
  478.     }
  479.  
  480.     if (tetra != null)
  481.         tetra.setCapability(GeometryArray.ALLOW_REF_DATA_WRITE);
  482.     return tetra;
  483.     }
  484.  
  485.     public void updateData(Geometry geometry) {
  486.     int i;
  487.     float val;
  488.  
  489.     
  490.     if (updateIndex == 1) { // geometry
  491.         // Translate the geometry by a small amount in x
  492.         vertexCount++;
  493.         if ((vertexCount &1) == 1)
  494.         val = 0.2f;
  495.         else
  496.         val = -0.2f;
  497.  
  498.         if (vertexIndex == 0) {
  499.         // Do Indexed geometry
  500.         for (i = 0; i < indexedFloatVerts.length; i+=3) {
  501.             indexedFloatVerts[i] += val;
  502.         }
  503.         // Do non-indexed float geometry
  504.         for (i = 0; i < floatVerts.length; i+=3) {
  505.             floatVerts[i] += val;
  506.         }
  507.         }
  508.         else {
  509.         // If p3f do each point only once
  510.         for (i = 0; i < indexedP3fVerts.length; i++) {
  511.             indexedP3fVerts[i].x += val;
  512.         }
  513.         }
  514.  
  515.     }
  516.     else if (updateIndex == 2) { // colors
  517.         colorCount++;
  518.         if ((colorCount & 1) == 1)
  519.         val = 0.4f;
  520.         else
  521.         val = -0.4f;
  522.         if (colorIndex == 0) {
  523.         // Do Indexed geometry
  524.         for (i = 0; i < indexedFloatClrs.length; i+=3) {
  525.             indexedFloatClrs[i] += val;
  526.         }
  527.         // Do non-indexed float geometry
  528.         for (i = 0; i < floatClrs.length; i+=3) {
  529.             floatClrs[i] += val;
  530.         }
  531.         }
  532.         else {
  533.         // If c3f do each point only once        
  534.         for (i = 0; i < indexedC3fClrs.length; i++) {
  535.             indexedC3fClrs[i].x += val;
  536.         }
  537.         }
  538.  
  539.     }
  540.  
  541.     }
  542. }
  543.